from utils.key import is_valid_redis_key, get_all_keys
from redisData.rServer import RS

# hash_data = RS.rDB[rClient.redisDbId].hash_data

# 辅助：审查key是否为hash key
def check_hash_key(key, rClient):
    """
    string:key -> string:key_status ["new","invalid","ok","error"] \n
    ["不存在，可新建","不存在，非法","是hash key,直接使用","非hash key,报错"]
    """
    key_status = ""  # ["new","invalid","ok","error"] : ["不存在，可新建","不存在，非法","是hash key，直接使用","非hash key，报错"]

    # 审查这个key是否已存在，且是否为hash的key
    all_keys_dict = get_all_keys(rClient)
    if not (key in all_keys_dict.keys()):
        # 如果不存在，去审查新key是否合法。
        if is_valid_redis_key(key):  # 判断键是否合法
            key_status = "new"
        else:
            key_status = "invalid"
    # 如果存在
    else:
        # 不是 hash key -> 此key不能用，报错
        if all_keys_dict[key] != "hash":
            key_status = "error"
        # 是 hash key -> 直接用
        else:
            key_status = "ok"
    return key_status


# 辅助：审查已存key下是否存在该field
def check_hash_field(key, field, rClient):
    """
    string:key,string:field -> string field_status ["exist","not_exist"]\n
    审查已存key下是否存在该field
    """
    field_status = ""  # ["exist","not_exist"]
    # key下存在该field
    hash_data = RS.rDB[rClient.redisDbId].hash_data
    if (field in hash_data[key].keys()):
        field_status = "exist"
    else:
        field_status = "not_exist"
    return field_status


# hset函数 hset key field value [field value ...]
def hset(cmd_list, rClient):
    """
    将哈希表key中的域field的值设置为value。
    """
    func_name = cmd_list.pop(0)  # 除去第一个函数名
    # 如果只有函数名没有参数,报错：参数数量不对 ； 帮助：此函数语法
    if (len(cmd_list) == 0):
        return f"(error) ERR syntax error: wrong number of arguments for '{func_name}' command\n(syntax help) hset key field value [field value ...]"
    key = cmd_list.pop(0)  # 获取第二个参数也就是key
    # 审查key
    key_status = check_hash_key(key, rClient)
    # 审查通过
    if (key_status == "ok") or (key_status == "new"):
        hash_data = RS.rDB[rClient.redisDbId].hash_data
        # key不存在，新建
        if (key_status == "new"):
            hash_data[key] = {}  # 初始化1级字典
        # 看剩下的参数是否为偶数 field value [field value ...]
        # 是偶数且>0 -> 取一对(field,value),直到没有参数
        # !注意：后续的fv对会覆盖前面的fv对
        if (len(cmd_list) % 2 == 0) and (len(cmd_list) > 0):
            while (len(cmd_list) > 0):
                field = cmd_list.pop(0)
                value = cmd_list.pop(0)
                hash_data[key][field] = value
            return "OK"
            # 不符合(key后无参数，或field缺少对应value) -> 语法报错
        else:
            # key后缺失field
            if (len(cmd_list) == 0):
                return f"(error) ERR syntax error: wrong number of arguments '{func_name}' command - field missing(after key)"
            # field后缺失value
            if (len(cmd_list) % 2 != 0):
                return f"(error) ERR syntax error: wrong number of arguments '{func_name}' command - value missing(after field)"
    # 审查不通过
    else:
        # key非法
        if (key_status == "invalid"):
            return "(error) Invalid key"
        # 不是hash key
        else:
            return "(error) WRONGTYPE Operation against a key holding the wrong kind of value"


# hsetnx key field value
def hsetnx(cmd_list, rClient):
    """
    当且仅当field不存在的时候，将哈希表key中的域field的值设置为value。
    """
    func_name = cmd_list.pop(0)  # 除去第一个函数名
    # 如果只有函数名没有参数,报错：参数数量不对 ； 帮助：此函数语法
    if (len(cmd_list) == 0):
        return f"(error) ERR syntax error: wrong number of " \
               f"arguments for '{func_name}' command\n(syntax help) hsetnx key field value"

    # 剩下的参数是否是3个
    # 不是3个 -> 报错：参数数量错误
    if (len(cmd_list) != 3):
        return f"(error) ERR syntax error: wrong number of arguments for '{func_name}' command"
        # 就是3个
    else:
        key = cmd_list.pop(0)  # 获取第二个参数也就是key
        # 审查key
        key_status = check_hash_key(key, rClient)
        # 审查通过
        if (key_status == "ok") or (key_status == "new"):
            hash_data = RS.rDB[rClient.redisDbId].hash_data
            # 若key不存在，新建
            if (key_status == "new"):
                hash_data[key] = {}  # 初始化1级字典
            field = cmd_list.pop(0)

            # 审查field是否存在
            field_status = check_hash_field(key, field, rClient)
            # field不存在
            if (field_status == "not_exist"):
                value = cmd_list.pop(0)  # 获取第四个参数value
                hash_data[key][field] = value
                return "OK"
                # field存在
            else:
                return f"(error) field '{field}' has already existed"
        # 审查不通过
        else:
            # key非法
            if (key_status == "invalid"):
                return "(error) Invalid key"
            # 不是hash key
            else:
                return "(error) WRONGTYPE Operation against" \
                       " a key holding the wrong kind of value"


# hget函数 hget key field
def hget(cmd_list, rClient):
    """
    返回哈希表key中给定域field的值。
    """
    func_name = cmd_list.pop(0)  # 除去第一个函数名
    # 如果只有函数名没有参数,报错：参数数量不对 ； 帮助：此函数语法
    if (len(cmd_list) == 0):
        return f"(error) ERR syntax error: wrong number " \
               f"of arguments for '{func_name}' command\n(syntax help) hget key field"

    # 剩下的参数是否是2个
    # 不是两个 -> 报错：参数数量错误
    if (len(cmd_list) != 2):
        return f"(error) ERR syntax error: wrong number of arguments for '{func_name}' command"
        # 就是两个
    else:
        key = cmd_list.pop(0)  # 获取第二个参数也就是key
        # 审查key
        key_status = check_hash_key(key, rClient)
        # 审查通过
        if (key_status == "ok"):
            field = cmd_list.pop(0)  # 获取第三个参数field
            # 审查field是否存在
            field_status = check_hash_field(key, field, rClient)
            # field存在
            if (field_status == "exist"):
                hash_data = RS.rDB[rClient.redisDbId].hash_data
                value = hash_data[key][field]
                return value
                # field不存在
            else:
                return "(nil)"

            # 审查不通过
        else:
            # key不存在
            if (key_status == "new"):
                return "(nil)"
                # key非法
            elif (key_status == "invalid"):
                return "(error) Invalid key"
                # 不是hash key
            else:
                return "(error) WRONGTYPE Operation against a key holding the wrong kind of value"


# hexists key field
def hexists(cmd_list, rClient):
    """
    判断给定域field是否存在于哈希表key中。
    """
    func_name = cmd_list.pop(0)  # 除去第一个函数名
    # 如果只有函数名没有参数,报错：参数数量不对 ； 帮助：此函数语法
    if (len(cmd_list) == 0):
        return f"(error) ERR syntax error: wrong number of arguments for '{func_name}' command\n(syntax help) hexists key field"

    # 剩下的参数是否是2个
    # 不是两个 -> 报错：参数数量错误
    if (len(cmd_list) != 2):
        return f"(error) ERR syntax error: wrong number of arguments for '{func_name}' command"
        # 就是两个
    else:
        key = cmd_list.pop(0)  # 获取第二个参数也就是key
        # 审查key
        key_status = check_hash_key(key, rClient)
        # 审查通过
        if (key_status == "ok"):
            field = cmd_list.pop(0)  # 获取第三个参数field
            # 审查field是否存在
            field_status = check_hash_field(key, field, rClient)
            # field存在
            if (field_status == "exist"):
                return "(integer) 1"
                # field不存在
            else:
                return "(integer) 0"

            # 审查不通过
        else:
                # key不存在
            if (key_status == "new"):
                return "(integer) 0"
                # key非法
            elif (key_status == "invalid"):
                return "(error) Invalid key"
                # 不是hash key
            else:
                return "(error) WRONGTYPE Operation against a key holding the wrong kind of value"

#hdel key field [field ...]
def hdel(cmd_list,rClient):
    """
    删除哈希表key中的⼀个或多个指定域field。\n
    只删除确实存在的field，对于不存在的field，跳过,不返回报错。\n
    返回删除成功计数。\n

    删除的时候你难道还管存不存在？
    """
    func_name = cmd_list.pop(0)  # 除去第一个函数名
    # 如果只有函数名没有参数,报错：参数数量不对 ； 帮助：此函数语法
    if (len(cmd_list) == 0):
        return f"(error) ERR syntax error: wrong number of arguments for '{func_name}' command\n" \
                f"(syntax help) hdel key field [field ...]"
    # 参数数量不够(只有一个key)
    if (len(cmd_list)<2):
        return f"(error) ERR syntax error: wrong number of arguments for '{func_name}' command" \
                f" - field missing(after key)"
    # 参数>=2个
    else:
        key = cmd_list.pop(0)  # 获取第二个参数也就是key
        # 审查key
        key_status = check_hash_key(key, rClient)
        # 审查通过
        if (key_status == "ok"):
            # 剩下的参数
            # 删除成功计数
            delete_count = 0
            hash_data = RS.rDB[rClient.redisDbId].hash_data
            # 读取下一个field
            while (len(cmd_list) > 0):
                field = cmd_list.pop(0)
                field_status = check_hash_field(key,field,rClient)
                if field_status == "exist":
                    hash_data[key].pop(field)
                    delete_count += 1
            return f"(integer) {delete_count}"
            # 审查不通过
        else:
            # key不存在
            if (key_status == "new"):
                return "(integer) 0"
            # key非法
            elif (key_status == "invalid"):
                return "(error) Invalid key"
            # 不是hash key
            else:
                return "(error) WRONGTYPE Operation against a key holding the wrong kind of value"

# hlen key
def hlen(cmd_list,rClient):
    """
    返回哈希表key中域的数量。\n
    不存在的key返回 (integer) 0
    """
    func_name = cmd_list.pop(0)  # 除去第一个函数名
    # 如果只有函数名没有参数,报错：参数数量不对 ； 帮助：此函数语法
    if (len(cmd_list) == 0):
        return f"(error) ERR syntax error: wrong number of arguments for '{func_name}' command\n" \
                f"(syntax help) hlen key"
    # 参数过多
    if (len(cmd_list)>1):
        return f"(error) ERR syntax error: wrong number of arguments for '{func_name}' command"
    # 参数数量正确 1个
    else:
        key = cmd_list.pop(0)  # 获取第二个参数也就是key
        # 审查key
        key_status = check_hash_key(key, rClient)
            # 审查通过
        if (key_status == "ok"):
            hash_data = RS.rDB[rClient.redisDbId].hash_data
                # 获取key下field数量
            field_count = len(hash_data[key].keys())
            return f"(integer) {field_count}"
            # 审查不通过
        else:
                # key不存在
            if (key_status == "new"):
                return "(integer) 0"
                # key非法
            elif (key_status == "invalid"):
                return "(error) Invalid key"
                # 不是hash key
            else:
                return "(error) WRONGTYPE Operation against a key holding the wrong kind of value"

# hstrlen key field
def hstrlen(cmd_list,rClient):
    """
    返回哈希表key中，给定域field相关联的值的字符串⻓度。\n
    若key或field不存在，返回 (integer) 0
    """
    func_name = cmd_list.pop(0)  # 除去第一个函数名
    # 如果只有函数名没有参数,报错：参数数量不对 ； 帮助：此函数语法
    if (len(cmd_list) == 0):
        return f"(error) ERR syntax error: wrong number of arguments for '{func_name}' command\n" \
                f"(syntax help) hstrlen key field"
    # 参数数量错误(不为2)
    if (len(cmd_list)!=2):
        return f"(error) ERR syntax error: wrong number of arguments for '{func_name}' command"
    # 参数数量正确 2个
    else:
        key = cmd_list.pop(0)  # 获取第二个参数也就是key
        # 审查key
        key_status = check_hash_key(key, rClient)
            # 审查通过
        if (key_status == "ok"):
            field = cmd_list.pop(0) # 获取第三个参数field
            field_status = check_hash_field(key,field,rClient)
                # 审查field-存在
            if (field_status=="exist"):
                hash_data = RS.rDB[rClient.redisDbId].hash_data
                    # 获取key下field关联的值的长度
                field_len = len(hash_data[key][field])
                return f"(integer) {field_len}"
                # 审查field-不存在
            else:
                return "(integer) 0"
            # 审查不通过
        else:
                # key不存在
            if (key_status == "new"):
                return "(integer) 0"
                # key非法
            elif (key_status == "invalid"):
                return "(error) Invalid key"
                # 不是hash key
            else:
                return "(error) WRONGTYPE Operation against a key holding the wrong kind of value"

# 两个辅助函数，判断字符串内是否为整数或浮点数
def is_strInt(inputStr):
    try:
        inputStr = int(inputStr)
        return isinstance(inputStr,int)
    except ValueError:
        return False

def is_strFloat(inputStr):
    try:
        inputStr = float(inputStr)
        return isinstance(inputStr,float)
    except ValueError:
        return False

# hincrby key field increment
# 参考以下链接，写了两个辅助函数，判断字符串内是否为整数或浮点数
# https://blog.csdn.net/m0_37622530/article/details/81289520
# https://blog.csdn.net/cj5230151/article/details/72874429
def hincrby(cmd_list,rClient):
    """
    将哈希表key中field的值加上增量increment。\n
    要求操作的field值必须为整数。返回增加过后，field的新值\n
    如果不是整数，报错 (error) ERR hash value is not an integer\n
    如果增量increment不是整数，报错(error) ERR value is not an integer or out of range\n
    如果key和field不存在，则自动初始化。(增加前，默认值为0)\n
    需要辅助函数：is_strInt(inputStr)
    """
    func_name = cmd_list.pop(0)  # 除去第一个函数名
    # 如果只有函数名没有参数,报错：参数数量不对 ； 帮助：此函数语法
    if (len(cmd_list) == 0):
        return f"(error) ERR syntax error: wrong number of arguments for '{func_name}' command\n" \
                f"(syntax help) hincrby key field increment"
    # 参数数量错误(不为3)
    if (len(cmd_list)!=3):
        return f"(error) ERR syntax error: wrong number of arguments for '{func_name}' command"
    # 参数数量正确 3个
    else:
        key = cmd_list.pop(0)  # 获取第二个参数也就是key
        # 审查key
        key_status = check_hash_key(key, rClient)
            # 审查通过
        if (key_status == "ok") or (key_status == "new") :
            hash_data = RS.rDB[rClient.redisDbId].hash_data
                # 若key不存在，需要初始化此key
            if (key_status == "new"):
                hash_data[key]={}

            field = cmd_list.pop(0) # 获取第三个参数field
            field_status = check_hash_field(key,field,rClient)
                # 若field不存在，初始化此field = "0"
            if (field_status=="not_exist"):
                hash_data[key][field]="0"
                # 若field存在 但其字符串的值不为整数，报错
            else:
                if not (is_strInt(hash_data[key][field])):
                    return "(error) ERR hash value is not an integer"
            
            increment = cmd_list.pop(0) # 获取第四个参数increment
                # 若increment字符串值不为整数，报错
            if not(is_strInt(increment)):
                return "(error) ERR value is not an integer or out of range"
            
            hash_data[key][field] = str(int(hash_data[key][field]) + int(increment))

            return f"integer ({hash_data[key][field]})"


            # 审查不通过
        else:
                # key非法
            if (key_status == "invalid"):
                return "(error) Invalid key"
                # 不是hash key
            else:
                return "(error) WRONGTYPE Operation against a key holding the wrong kind of value"

# hincrbyfloat key field increment            
def hincrbyfloat(cmd_list,rClient):
    """
    将哈希表key中field的值加上增量increment。\n
    要求操作的field值必须为浮点数。返回增加过后，field的新值\n
    如果field不是浮点数，报错 (error) ERR hash value is not an float\n
    如果增量increment不是浮点数，报错(error) ERR value is not an float or out of range\n
    如果key和field不存在，则自动初始化。(增加前，默认值为0)\n
    需要辅助函数：is_strFloat(inputStr)\n

    注: 这种浮点不存在小数点后n位的误差
    """
    func_name = cmd_list.pop(0)  # 除去第一个函数名
    # 如果只有函数名没有参数,报错：参数数量不对 ； 帮助：此函数语法
    if (len(cmd_list) == 0):
        return f"(error) ERR syntax error: wrong number of arguments for '{func_name}' command\n" \
                f"(syntax help) hincrby key field increment"
    # 参数数量错误(不为3)
    if (len(cmd_list)!=3):
        return f"(error) ERR syntax error: wrong number of arguments for '{func_name}' command"
    # 参数数量正确 3个
    else:
        key = cmd_list.pop(0)  # 获取第二个参数也就是key
        # 审查key
        key_status = check_hash_key(key, rClient)
            # 审查通过
        if (key_status == "ok") or (key_status == "new") :
            hash_data = RS.rDB[rClient.redisDbId].hash_data
                # 若key不存在，需要初始化此key
            if (key_status == "new"):
                hash_data[key]={}

            field = cmd_list.pop(0) # 获取第三个参数field
            field_status = check_hash_field(key,field,rClient)
                # 若field不存在，初始化此field = "0"
            if (field_status=="not_exist"):
                hash_data[key][field]="0"
                # 若field存在 但其字符串的值不为浮点数，报错
            else:
                if not (is_strFloat(hash_data[key][field])):
                    return "(error) ERR hash value is not an float"
            
            increment = cmd_list.pop(0) # 获取第四个参数increment
                # 若increment字符串值不为浮点数，报错
            if not(is_strFloat(increment)):
                return "(error) ERR value is not an float or out of range"
            
            hash_data[key][field] = str(float(hash_data[key][field]) + float(increment))

            return f"\"{hash_data[key][field]}\""


            # 审查不通过
        else:
                # key非法
            if (key_status == "invalid"):
                return "(error) Invalid key"
                # 不是hash key
            else:
                return "(error) WRONGTYPE Operation against a key holding the wrong kind of value"
            

# hmget key field [field ...]
def hmget(cmd_list, rClient):
    """
    返回哈希表key中⼀个或多个给定域field的值。\n
    对于不存在的key或field，返回(nil)\n
    返回格式：\n
    1) value\n
    2) (nil)\n
    """
    func_name = cmd_list.pop(0)  # 除去第一个函数名
    # 如果只有函数名没有参数,报错：参数数量不对 ； 帮助：此函数语法
    if (len(cmd_list) == 0):
        return f"(error) ERR syntax error: wrong number " \
               f"of arguments for '{func_name}' command\n(syntax help) hmget key field [field ...]"

    # 剩下的参数是否>=2
    # <2 (只有key) -> 报错：参数数量错误
    if (len(cmd_list) < 2):
        return f"(error) ERR syntax error: wrong number of arguments for '{func_name}' command"
        # 比2多
    else:
        key = cmd_list.pop(0)  # 获取第二个参数也就是key
        # 审查key
        key_status = check_hash_key(key, rClient)
        # 审查通过
        if (key_status == "ok"):
            hash_data = RS.rDB[rClient.redisDbId].hash_data
            valueList = []
            while(len(cmd_list)>0):
                field = cmd_list.pop(0)  # 获取下个参数field
                # 审查field是否存在
                field_status = check_hash_field(key, field, rClient)
                # field存在
                if (field_status == "exist"):
                    value = hash_data[key][field]
                    valueList.append(value)
                    # field不存在
                else:
                    valueList.append("(nil)")
            
            # 返回值
            return_msg = ""
            for index,value in enumerate(valueList):
                return_msg += f"{index+1}) {value}\n"
            return return_msg[:-1]  #[:-1] 去掉末尾的换行符

            # 审查不通过
        else:
            # key不存在 每个value都为(nil)
            if (key_status == "new"):
                valueList = []
                while(len(cmd_list)>0):
                    cmd_list.pop(0)
                    valueList.append("(nil)")
                return_msg = ""
                for index,value in enumerate(valueList):
                    return_msg += f"{index+1}) {value}\n"
                return return_msg[:-1]  #[:-1] 去掉末尾的换行符
                # key非法
            elif (key_status == "invalid"):
                return "(error) Invalid key"
                # 不是hash key
            else:
                return "(error) WRONGTYPE Operation against a key holding the wrong kind of value"
            
# hkeys key
def hkeys(cmd_list, rClient):
    """
    返回哈希表key中的所有域。
    返回格式：\n
    1) "f1"\n
    2) "f2"\n

    对于不存在的key，返回(empty list or set)
    """
    func_name = cmd_list.pop(0)  # 除去第一个函数名
    # 如果只有函数名没有参数,报错：参数数量不对 ； 帮助：此函数语法
    if (len(cmd_list) == 0):
        return f"(error) ERR syntax error: wrong number " \
               f"of arguments for '{func_name}' command\n(syntax help) hkeys key"

   
    # 参数过多>1 -> 报错：参数数量错误
    if (len(cmd_list) > 1):
        return f"(error) ERR syntax error: wrong number of arguments for '{func_name}' command"
        # 参数只有一个 key
    else:
        key = cmd_list.pop(0)  # 获取第二个参数也就是key
        # 审查key
        key_status = check_hash_key(key, rClient)
        # 审查通过
        if (key_status == "ok"):
            hash_data = RS.rDB[rClient.redisDbId].hash_data
            field_list = hash_data[key].keys()
            
            # 返回值
            return_msg = ""
            for index,field in enumerate(field_list):
                return_msg += f"{index+1}) {field}\n"
            return return_msg[:-1]  #[:-1] 去掉末尾的换行符

            # 审查不通过
        else:
            # key不存在 
            if (key_status == "new"):
                return "(empty list or set)"
                # key非法
            elif (key_status == "invalid"):
                return "(error) Invalid key"
                # 不是hash key
            else:
                return "(error) WRONGTYPE Operation against a key holding the wrong kind of value"
            
# hvals key
def hvals(cmd_list, rClient):
    """
    返回哈希表key中所有域的值。\n
    返回格式：\n
    1) value1\n
    2) value2\n

    对于不存在的key 返回"(empty list or set)"
    """
    func_name = cmd_list.pop(0)  # 除去第一个函数名
    # 如果只有函数名没有参数,报错：参数数量不对 ； 帮助：此函数语法
    if (len(cmd_list) == 0):
        return f"(error) ERR syntax error: wrong number " \
               f"of arguments for '{func_name}' command\n(syntax help) hvals key"

    # 参数过多(>1) -> 报错：参数数量错误
    if (len(cmd_list) > 1):
        return f"(error) ERR syntax error: wrong number of arguments for '{func_name}' command"
        # 参数正确，只有一个key
    else:
        key = cmd_list.pop(0)  # 获取第二个参数也就是key
        # 审查key
        key_status = check_hash_key(key, rClient)
        # 审查通过
        if (key_status == "ok"):
            hash_data = RS.rDB[rClient.redisDbId].hash_data
            valueList = hash_data[key].values()
            
            # 返回值
            return_msg = ""
            for index,value in enumerate(valueList):
                return_msg += f"{index+1}) {value}\n"
            return return_msg[:-1]  #[:-1] 去掉末尾的换行符

            # 审查不通过
        else:
            # key不存在 
            if (key_status == "new"):
                return "(empty list or set)"
                # key非法
            elif (key_status == "invalid"):
                return "(error) Invalid key"
                # 不是hash key
            else:
                return "(error) WRONGTYPE Operation against a key holding the wrong kind of value"
            
# hgetall key
def hgetall(cmd_list, rClient):
    """
    返回哈希表key中所有的域和值\n
    返回格式：\n
    1) field1\n
    2) value1\n
    3) field2\n
    4) value2\n

    对于不存在的key 返回"(empty list or set)"
    """
    func_name = cmd_list.pop(0)  # 除去第一个函数名
    # 如果只有函数名没有参数,报错：参数数量不对 ； 帮助：此函数语法
    if (len(cmd_list) == 0):
        return f"(error) ERR syntax error: wrong number " \
               f"of arguments for '{func_name}' command\n(syntax help) hgetall key"

    # 参数过多(>1) -> 报错：参数数量错误
    if (len(cmd_list) > 1):
        return f"(error) ERR syntax error: wrong number of arguments for '{func_name}' command"
        # 参数正确，只有一个key
    else:
        key = cmd_list.pop(0)  # 获取第二个参数也就是key
        # 审查key
        key_status = check_hash_key(key, rClient)
        # 审查通过
        if (key_status == "ok"):
            hash_data = RS.rDB[rClient.redisDbId].hash_data
            fv_pair = hash_data[key].items() #[(f1,v1),(f2,v2)...]
            
            # 返回值
            return_msg = ""
            for index,pair in enumerate(fv_pair):
                return_msg += f"{index+1}) {pair[0]} {pair[1]}\n"
                # return_msg += f"{index+2}) {pair[1]}\n"
            return return_msg[:-1]  #[:-1] 去掉末尾的换行符

            # 审查不通过
        else:
            # key不存在 
            if (key_status == "new"):
                return "(empty list or set)"
                # key非法
            elif (key_status == "invalid"):
                return "(error) Invalid key"
                # 不是hash key
            else:
                return "(error) WRONGTYPE Operation against a key holding the wrong kind of value"